今天，我們將學習 Rust 在系統程式設計中的應用，包括如何與作業系統互動、處理底層硬體，以及在嵌入式系統中使用 Rust。

1. 與作業系統互動

Rust 提供了豐富的標準函式庫功能，讓我們能夠方便地與作業系統互動。

檔案系統操作

使用 std::fs 模組來進行檔案系統操作：

use std::fs::{File, OpenOptions};
use std::io::{Read, Write};

fn main() -> std::io::Result<()> {
    // 寫入檔案
    let mut file = File::create("example.txt")?;
    file.write_all(b"Hello, Rust!")?;

    // 讀取檔案
    let mut contents = String::new();
    File::open("example.txt")?.read_to_string(&mut contents)?;
    println!("檔案內容: {}", contents);

    // 附加到檔案
    let mut file = OpenOptions::new().append(true).open("example.txt")?;
    file.write_all(b"\n append text")?;

    Ok(())
}

處理環境變數

使用 std::env 模組來處理環境變數：

use std::env;

fn main() {
    // 設置環境變數
    env::set_var("MY_VAR", "我的值");

    // 讀取環境變數
    match env::var("MY_VAR") {
        Ok(val) => println!("MY_VAR: {}", val),
        Err(e) => println!("無法讀取 MY_VAR: {}", e),
    }

    // 遍歷所有環境變數
    for (key, value) in env::vars() {
        println!("{}: {}", key, value);
    }
}

2. 系統呼叫和底層操作

Rust 允許我們進行底層系統操作，包括直接進行系統呼叫。

使用 libc 進行系統呼叫

使用 libc crate 來進行系統呼叫：

Cargo.toml

[package]
name = "my_calculator"
version = "0.1.0"
edition = "2021"

# See more keys and their definitions at https://doc.rust-lang.org/cargo/reference/manifest.html

[dependencies]
rand = "0.8.5"
serde = { version = "1.0", features = ["derive"] }
thiserror = "1.0.63"
serde_json = "1.0.128"
tokio = { version = "1.40.0", features = ["rt", "rt-multi-thread", "macros"] }
reqwest = "0.12.7"
futures = "0.3.30"
quote = "1.0.37"
syn = "2.0.77"
libc = "0.2.158"
sysinfo = "0.26.2"

use libc::{c_char, c_int};
use std::ffi::CString;

extern "C" {
    fn printf(format: *const c_char, ...) -> c_int;
}

fn main() {
    let message = CString::new("從 Rust 呼叫 C 函式：Hello, %s!\n").unwrap();
    let name = CString::new("World").unwrap();
    unsafe {
        printf(message.as_ptr(), name.as_ptr());
    }
}

3. 嵌入式系統開發

Rust 在嵌入式系統開發中越來越受歡迎，因為它提供了記憶體安全和高效能。

使用 embedded-hal

embedded-hal 是一個用於嵌入式系統開發的抽象層：

use embedded_hal::digital::v2::OutputPin;
use embedded_hal::delay::DelayMs;

struct MyBoard {
    led: MyLed,
    delay: MyDelay,
}

impl MyBoard {
    fn blink(&mut self) -> Result<(), MyError> {
        self.led.set_high()?;
        self.delay.delay_ms(1000u32);
        self.led.set_low()?;
        self.delay.delay_ms(1000u32);
        Ok(())
    }
}

// 假設的實作，實際使用時需要根據具體硬體實作
struct MyLed;
struct MyDelay;
struct MyError;

impl OutputPin for MyLed {
    type Error = MyError;
    fn set_low(&mut self) -> Result<(), Self::Error> { Ok(()) }
    fn set_high(&mut self) -> Result<(), Self::Error> { Ok(()) }
}

impl DelayMs<u32> for MyDelay {
    fn delay_ms(&mut self, ms: u32) { /* 實際延遲實作 */ }
}

4. 網路程式設計

Rust 提供了強大的網路程式設計能力，包括低層級和高層級的 API。

使用 std::net 進行 TCP 連接

use std::net::{TcpListener, TcpStream};
use std::io::{Read, Write};

fn handle_client(mut stream: TcpStream) {
    let mut buffer = [0; 512];
    stream.read(&mut buffer).unwrap();
    stream.write(b"收到你的訊息！\n").unwrap();
}

fn main() -> std::io::Result<()> {
    let listener = TcpListener::bind("127.0.0.1:7878")?;

    for stream in listener.incoming() {
        handle_client(stream?);
    }
    Ok(())
}

實際應用範例：簡單的系統監控工具

讓我們建立一個簡單的系統監控工具，它可以顯示 CPU 使用率和記憶體使用情況：

use std::thread;
use std::time::Duration;
use sysinfo::{SystemExt, CpuExt, System};

fn main() {
    let mut sys = System::new_all();

    loop {
        sys.refresh_all();

        // CPU 使用率
        let cpu_usage: f32 = sys
            .cpus()
            .iter()
            .map(|cpu| cpu.cpu_usage())
            .sum::<f32>()
            / sys.cpus().len() as f32;

        // 記憶體使用情況
        let total_memory = sys.total_memory();
        let used_memory = sys.used_memory();
        let memory_usage = (used_memory as f64 / total_memory as f64) * 100.0;

        println!("CPU 使用率: {:.2}%", cpu_usage);
        println!("記憶體使用率: {:.2}%", memory_usage);
        println!("------------------------");

        thread::sleep(Duration::from_secs(1));
    }
}